Constructing an independent ReadOnlyBase

[michaelcsikos]

As we generally need to construct objects via the DataPortal rather than constructors, for a ReadOnlyBase which is independent and not part of a ReadOnlyBindingListBase which DataPortal method is the most appropriate? DataPortal.FetchChild<T>(...) is convenient because it accepts params thus being the most similar to a simple constructor with multiple parameters. Is this OK? Is there anything particularly special about FetchChild for read-only objects?

[rockfordlhotka]

I don't understand the scenario?

You just want to create a readonly object without talking to the server? That's easily done by using RunLocal:

[Fetch]
[RunLocal]
private void Fetch(...)
{
}

Then

var obj = await DataPortal.FetchAsync<...>();

[michaelcsikos]

Just to clarify the scenario, with a typical ReadOnlyBindingListBase of ReadOnlyBase info objects, we do a DataPortal.FetchChild passing in a DTO, EF object, or could even just be some parameter values.

Sometimes we need to fetch just one ReadOnlyBase info object directly. As it's not contained in a ReadOnlyBindingListBase I just wasn't sure if I should being using DataPortal.Fetch or DataPortal.FetchChild.

In the past we've just used an internal constructor and created the instance directly.

[michaelcsikos]

Is there anything wrong with using an internal constructor for read-only objects?

[michaelcsikos]

[Serializable]
public class ExampleInfo
    : ReadOnlyBase<ExampleInfo>
{
    public static readonly PropertyInfo<Guid> IdProperty = RegisterProperty<Guid>(nameof(Id));
    public Guid Id
    {
        get { return ReadProperty(IdProperty); }
        private set { LoadProperty(IdProperty, value); }
    }

    public static readonly PropertyInfo<string> NameProperty = RegisterProperty<string>(nameof(Name));
    public string Name
    {
        get { return ReadProperty(NameProperty); }
        private set { LoadProperty(NameProperty, value); }
    }

    public static readonly PropertyInfo<string> CategoryProperty = RegisterProperty<string>(nameof(Category));
    public string Category
    {
        get { return ReadProperty(CategoryProperty); }
        private set { LoadProperty(CategoryProperty, value); }
    }

    // Is this OK?
    internal ExampleInfo(Guid id, string name, string category)
    {
        Id       = id;
        Name     = name;
        Category = category;
    }

    public ExampleInfo()
    {
    }
}

[rockfordlhotka]

The answer should be pretty straightforward.

If you are retrieving an object (list or single) from the client, then you should use the root methods (like FetchAsync).

If you are retrieving an object from within another object while already on the server then you should use the child objects (like FetchChildAsync).

[rockfordlhotka]

btw, nothing stops your readonlybase type from having both types of fetch operation method.

  [Fetch]
  private void Fetch()
  {}

  [FetchChild]
  private void FetchChild()
  {}

And if they do the same thing (and require the same parameters), they can be the same method.

  [Fetch]
  [FetchChild]
  private void Fetch()
  {}