Can a static constructor be made for the child of an abstract class?

Question

I am completely new to async/await and have been "improving" a totally synchronous app I wrote two years ago. I have the following situation that I am unhappy with my solution.

The XAML is bound to the following two classes:

XAML

private InsuranceEditor _primaryinsurance;
public InsuranceEditor PrimaryInsurance
{
      get { return _primaryinsurance; }
      set { if (_primaryinsurance == value) return; _primaryinsurance = value; OnPropertyChanged("PrimaryInsurance"); }
}

private InsuranceEditor _secondaryinsurance;
public InsuranceEditor SecondaryInsurance
{
       get { return _secondaryinsurance; }
       set { if (_secondaryinsurance == value) return; _secondaryinsurance = value; OnPropertyChanged("SecondaryInsurance"); }
}

The classes, PrimaryInsurance, and SecondaryInsurance inherit from the abstract class Insurance:

abstract class InsuranceEditor : SimpleViewModelBase, ISave, IDataErrorInfo
{
           .................
           // Constructor
    public InsuranceEditor(PatientDemographicsEditor patient, Billing service)
    {
        ...
    } 

Factory pattern used for asynchronous construction of PrimaryInsurance (Async OOP Constructor)

private async Task<PrimaryInsurance> InitializeAsync()
{
    // asyncData = await GetDataAsync();
    return this;
}

public static Task<PrimaryInsurance> Create(PatientDemographicsEditor patient, Billing service)
{
    var ret = new PrimaryInsurance(patient, service);
    return ret.InitializeAsync();
}

// Constructor 
private PrimaryInsurance(PatientDemographicsEditor patient, Billing service)
    : base(patient, service)
{
    Editor_Id = 1;
     ........
}

class SecondaryInsurance : InsuranceEditor
{
    // Constructor
    private SecondaryInsurance(PatientDemographicsEditor patient, Billing service)
        : base(patient, service)
    {
        Editor_Id = 2;
      ............................
    }
}

Logically, both primary and secondary insurance only differ in their Editor_Id, so it seemed natural to inherit from a common InsuranceEditor. The problem now comes with "correctly" applying async/await to the Primary and Secondary Insurance. I would like usage to be something like:

PrimaryInsurance = await PrimaryInsurance.Create(....) where Create(...) is recognized as a static method of PrimaryInsurance (not necessarily a static method of the abstract class InsuranceEditor.)

Can this be done?

Edit #1. After posting this question, I'm thinking it may have already been asked, What's the correct alternative to static method inheritance? and that what I want can't be done in C#. Is this correct?

Edit #2: The problem I am having in VS comes with the usage statement:

PrimaryInsurance = await PrimaryInsurance.Create(Patient, BILLING);

VS tells me that:

Member 'InsuranceEditor.Create(PatientDemographicsEditor, Billing)' cannot be accessed with an instance reference; qualify it with a type name instead

And then if I allow VS to make the Create(...) (so that there are no errors), it makes this in the abstact InsuranceEditor class, not the PrimaryInsurance Class.

internal Task<InsuranceEditor> Create(PatientDemographicsEditor patient, Billing bILLING)
        {
            throw new NotImplementedException();
        }

What am I doing wrong?

Answer 1

You still haven't provided a good Minimal, Complete, and Verifiable code example that reliably reproduces the problem. But based on the example program statement and the error message you've quoted, it appears that you are trying to use the PrimaryInsurance identifier in a context where it is ambiguous with the name of a property.

If you want to keep the name of the property, then anywhere you want to use the type name, you'll need to fully qualify it. For example:

PrimaryInsurance = await MyNamespace.PrimaryInsurance.Create(Patient, BILLING);

where MyNamespace is whatever the actual namespace is for the type.

If the namespace is especially long, or for any other reason you would prefer to not have to type the whole thing out every time, you can alias the type name with a using directive. For example:

using PrimaryInsuranceType = MyNamespace.PrimaryInsurance;

Then your program statement could look like this:

PrimaryInsurance = await PrimaryInsuranceType.Create(Patient, BILLING);

Of course, PrimaryInsuranceType is just an example. You can use whatever type alias name you want, as long as it's different from the property name itself (or any other property name in the class).