We Keep Coding

Pointer from derived class to base class C#

I have 100 classes that will inherit 1 base class. Derived class can have A and B property, just A or B property, or don't have them at all. I need a pointer, from derived class to base class, that will trigger every time I call A or B property from derived classes.
class D1 : Base
{
int A { get; set; } // Point to Base A
}
class D2 : Base
{
int A { get; set; } // Point to Base A
int B { get; set; } // Point to Base B
}
class Base
{
int A => ExampleA();
int B => ExampleB();
int ExampleA()
{
return 10;
}
int ExampleB()
{
return 15;
}
}
static void Main(string[] args)
{
D1 d1 = new D1();
D2 d2 = new D2();
d1.A; //return 10
d2.A; //return 10
d2.B; //return 15
}

If You want to inherit not everything but sometimes A, sometimes B and only sometimes A and B then it looks like You should not inherit from the base class at all. Looks more like You should create 2 interfaces and for example:
class D1 : IBaseA
class D2 : IBaseA, IBaseB

You'll want to make the properties on the base class virtual, so then classes that inherit from it can optionally override the behaivour. (Or you could also make the methods ExampleA and ExampleB virtual and optionally override that behaivour instead), like so:
public class Base
{
// Made these properties get and set, instead of get (read) only
// default values are for illustration purposes
public virtual int A { get; set; } = 1;
public virtual int B { get; set; } = 1;
}
public class Foo : Base
{
public override int A { get; set; } = 10;
}
public class Bar : Base
{
public override int B { get; set; } = 10;
}
Let's test it:
var a = new Foo();
var b = new Bar();
Console.WriteLine($"a.A: {a.A}, a.B: {a.B}");
Console.WriteLine($"b.A: {b.A}, b.B: {b.B}");
If you don't specify anything, Foo and Bar will implicitly have A and B with the same visibility as A and B in the Base class. You can't change the visiblity of a member of a class "after the fact" (i.e without changing it in the base class), so if only some of your classes should expose A or B you'll want to follow what CherryQuery said in their answer

Actually in Base class you don't need A and B. Subclasses should then look like (assuming ExampleX methods are at least protected):
class D1 : Base
{
public int A => ExampleA(); // note this is get-only property
}

How can I combine two classes with common members into a single input?

I need to create a service that takes 3 inputs, which basically boils down to A, B, and a combination of A and B which we will call C.
Suppose these classes are defined as follows:
public abstract class InputBase
{
public bool Option1 { get; set; }
public decimal Rate { get; set; }
public DateTime DateCreated { get; set; }
}
public class A : InputBase
{
public decimal Fee { get; set; }
}
public class B : InputBase
{
public decimal Fee { get; set; }
}
The Fees in A and B are distinct and separate and can be different, for cases like C where you can do a combination of A and B together in the same request.
We currently just have a class that looks like this:
public class C
{
public A A { get; set; }
public B B { get; set; }
}
However, this makes it extremely annoying to update any values that are common in both. For example:
var c = new C
{
A = new A(),
B = new B()
}
//this is ugly and what we want to avoid
c.A.DateCreated = DateTime.Now;
c.B.DateCreated = DateTime.Now;
We'd like to be able to do something like this:
c.DateCreated = DateTime.Now;
//later
var createdDate = c.A.DateCreated; //points to date created before
The naive way of doing this would be to implement setters that go and update both inner classes with the value, but then what do we do with the getters?
Also, should C inherit from InputBase, since it is technically an input to the service?
What is the correct way to go about this?

There are certain concerns about your inheritance structure. I don't disagree with other answers, but I feel that they've gotten distracted with these tangential elements.
I'm trying to only answer your direct question, which you already answered yourself:
The naive way of doing this would be to implement setters that go and update both inner classes with the value, but then what do we do with the getters?
You're correct about the getter issue, but keep in mind that the getter is not required to exist. You can have write-only properties. They are rare, but they have a purpose.
I'm also not sure what exactly is naive about it. Simple solutions are not bad. If anything, simple solutions are better than complex ones, if they manage to fix the same problem. KISS applies:
The KISS principle states that most systems work best if they are kept simple rather than made complicated; therefore simplicity should be a key goal in design and unnecessary complexity should be avoided.
Notice the emphasis on unnecessary complexity. If it's necessary, then it (by definition) serves a purpose.
var c = new C
{
A = new A(),
B = new B()
}
//this is ugly and what we want to avoid
c.A.DateCreated = DateTime.Now;
c.B.DateCreated = DateTime.Now;
A simple fix is to make a custom property in C:
public class C
{
public DateTime DateCreated
{
set
{
this.A.DateCreated = value;
this.B.DateCreated = value;
}
}
}
I omitted the getter because it wouldn't make much sense (would you display A.CreatedOn or B.CreatedOn)?
But it's not wrong to simply omit the getter, so that seems like the best approach here.
This creates the behavior you want:
//sets both values
c.DateCreated = DateTime.Now;
However, values are retrieved separately:
var createdDateA = c.A.DateCreated;
var createdDateB = c.B.DateCreated;
The naive way of doing this would be to implement setters that go and update both inner classes with the value, but then what do we do with the getters?
Besides my earlier feedback on this, if you're really averse to writeonly properties, you can basically convert them into a method. Functionally equivalent, but more explicitly doesn't expose a get method:
public class C
{
public void SetDateCreated(DateTime value)
{
this.A.DateCreated = value;
this.B.DateCreated = value;
}
}
Also, should C inherit from InputBase, since it is technically an input to the service?
Not unless C has its own Fee object which works exactly as the other derived InputBase classes.
This question is a bit broad; it hinges on the inheritance (and SOLID) concerns in your codebase. This is too big for a StackOverflow question. If you can rephrase this to a concrete question about the inheritance sturcture, it might be better suited to SoftwareEngineering.SE (or possibly CodeReview.SE, if you have working code).

You could make C derive from InputBase, as well as have a collection of InputBase.
public class C : InputBase, IHaveInputBase
{
IList<InputBase> IHaveInputBase.Inputs { get; set; }
}
public class Service
{
public void Handle(InputBase inputBase)
{
IHaveInputBase haveInputBase = inputBase as IHaveInputBase;
if (haveInputBase != null)
{
foreach (InputBase input in haveInputBase.Inputs)
{
this.Handle(input);
}
}
inputBase.DateCreated = this.dateTimeService.UtcNow();
...
}
}

I might not have understood you correctly, but why don't you make C inherit from InputBase and have an AFee and BFee:
class C: InputBase {
public decimal AFee { get; set; }
public decimal BFee { get; set; }
}
Then you could add constructors for C that takes an A and a B. This will check whether they have the same Option1, Rate and DateCreated. If they do, assign the C fields with their values. If they don't, throw an exception or something like that.
You could also have methods like GetA or GetB that creates A and B objects from C's values.
class C : InputBase {
public decimal AFee { get; set; }
public decimal BFee { get; set; }
public C(A a, B b) {
if (a.DateCreated == b.DateCreated && a.Option1 == b.Option1 && a.Rate == b.Rate) {
Option1 = a.Option1;
Rate = a.Rate;
DateCreated = a.DateCreated;
} else {
throw new ArgumentException("...");
}
}
public C() {}
public A GetA() {
return new A { DateCreated = DateCreated, Option1 = Option1, Rate = Rate, Fee = AFee };
}
public B GetB() {
return new B { DateCreated = DateCreated, Option1 = Option1, Rate = Rate, Fee = BFee };
}
}

1. You could use method for update input which takes action
public class C
{
public A A { get; }
public B B { get; }
public void UpdateInput(Action<InputBase> updateFunc)
{
updateFunc(A);
updateFunc(B);
}
}
And then just update any of your InputBase properties through Action.
var c = new C
{
A = new A(),
B = new B()
}
var dateTime = DateTime.UtcNow;
c.UpdateInput(input => input.DateCreated = dateTime);
2. Or you could make properties of InputBase virtual and override them like this
public abstract class InputBase
{
public virtual bool Option1 { get; set; }
public virtual decimal Rate { get; set; }
public virtual DateTime DateCreated { get; set; }
}
public class C : InputBase
{
private bool _option1;
public override bool Option1
{
get => _option1;
set
{
_option1 = value;
A.Option1 = value;
B.Option1 = value;
}
}
private decimal _rate;
public override decimal Rate
{
get => _rate;
set
{
_rate = value;
A.Rate = value;
B.Rate = value;
}
}
private DateTime _dateCreated;
public override DateTime DateCreated
{
get => _dateCreated;
set
{
_dateCreated = value;
A.DateCreated = value;
B.DateCreated = value;
}
}
public A A { get; }
public B B { get; }
}

Copying base class in derived class constructor

Is there a way to copy an object fields to a base class in a derived class constructor without having to individually copying every field?
Example:
public class A
{
int prop1 { get; set; }
int prop2 { get; set; }
}
public class B : A
{
public B(A a)
{
//base = a; doesn't work.
base.prop1 = a.prop1;
base.prop2 = a.prop2;
}
}
A a = new A();
B b = new B(a);

public class A
{
public A(A a)
{
prop1 = a.prop1;
prop2 = a.prop2;
}
int prop1 { get; set; }
int prop2 { get; set; }
}
public class B : A
{
public B(A a) : base (a)
{
}
}
A a = new A();
B b = new B(a);
Something like this, although I'm not sure if it is syntactically correct because I didn't compile it. You should use the base keyword after the child class's constructor to pass the values of it's dependencies to the base class.
Edit: But I just realized that you are passing a base class to a child class. And this is a design flaw.

It sounds like you want to add all properties from A to B without having to specify them all separately. If you don't want to have to keep adding new ones to the constructor, you could use reflection to do the work for you.
public B(A a)
{
var bType = this.GetType();
// specify that we're only interested in public properties
var aProps = a.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
// iterate through all the public properties in A
foreach (var prop in aProps)
{
// for each A property, set the same B property to its value
bType.GetProperty(prop.Name).SetValue(this, prop.GetValue(a));
}
}
A few notes about this:
The above code sets public instance properties, so you'd need to change your properties in A to be public.
I'd only consider this safe because you know that B contains everything in A (since it is derived from it).
If you only have a few properties, especially if they don't change often, just list them individually... it'll be easier to see exactly what your code is doing.

I can't for the life of me understand why you want to do this
You are passing an instance of Base class into the constructor of a derived class. What are you trying to do?
have you tried this = a instead of base = a?

The members are private, so you can't access them from even a derived class. Even if they were protected, you still couldn't access them on an instance of A from the B class.
In order to do this without reflection, the members will have to be public:
public class A
{
public int prop1 { get; set; }
public int prop2 { get; set; }
}
// Define other methods and classes here
public class B : A
{
public B(A a)
{
//base = a; doesn't work.
base.prop1 = a.prop1;
base.prop2 = a.prop2;
}
}

If you really want to do this and cannot access the properties via inheritance then you can do via reflection like this:
public class Aclass
{
public int Prop1 { get; set; }
public int Prop2 { get; set; }
}
public class Bclass : Aclass
{
public Bclass(Aclass aInstance)
{
CopyPropertiesFromAltInstance(aInstance);
}
public void CopyPropertiesFromAltInstance(Aclass aInstance)
{
PropertyInfo[] aProperties = aInstance.GetType().GetProperties();
PropertyInfo[] myProperties = this.GetType().GetProperties();
foreach (PropertyInfo aProperty in aProperties)
{
foreach (PropertyInfo myProperty in myProperties)
{
if (myProperty.Name == aProperty.Name && myProperty.PropertyType == aProperty.PropertyType)
{
myProperty.SetValue(this, aProperty.GetValue(aInstance));
}
}
}
}
}

Binding two objects of different classes but with similar properties

Is it possible in C# to bind two objects of different classes but with similar properties?
For Example:
class Program
{
static void Main(string[] args)
{
test t = new test();
test2 t2 = new test2();
}
}
public class test
{
public int Number { get; set; }
}
public class test2
{
public int Number { get; set; }
}
So is it possible to say t = t2 somewhow?

You can have both classes implement an interface, if you don't care about what implementation of the interface is used.
For example:
class Program
{
static void Main(string[] args)
{
INumber t = new test();
INumber t2 = new test2();
}
}
public class test : INumber
{
public int Number { get; set; }
}
public class test2 : INumber
{
public int Number { get; set; }
}
public interface INumber
{
int Number { get; set; }
}
An interface is a sort of contract, that provides a definition of what properties and methods an implementing class must define. You can read more on interfaces here.
When your classes implement a shared interface, you're able to to implicitly convert one type into another type, such as in the example above.

Without the addition of extra code, no, you cannot do that.
Even though they are "similar" they are regarded as totally different types by the compiler, and cannot be assigned to each other.
Now, you can include an implicit operator on one (or both) in order to allow implicit casting between the two.
public class test
{
public static implicit operator test(test2 t)
{
return new test(tt.Number);
}
public static implicit operator test2(test t)
{
return new test2(t.Number);
}
public int Number { get; set; }
}
But that is as close as you can get to supporting that syntax.

Best practice for protobuf-net, versioning and surrogate types

I'm trying to determine how to address this use case using protobuf-net (Marc Gravell's implementation).
We have class A, which is considered version 1
An instance of class A has been serialized to disk
We now have class B, which is considered version 2 of class A (there were so many things wrong with class A, we had to create class B for the next version). Class A still exists in code, but only for legacy purposes.
I want to deserialize the version:1 data (stored to disk) as a class B instance, and use a logic routine to translate the data from the previous class A instance to a new instance of class B.
The instance of class B will be serialized to disk during operation.
The application should expect to deserialize instances of both class A and B.
The concept of data contract surrogates and the DataContractSerializer come to mind. The goal is transition the version:1 data to the new class B structure.
An example:
[DataContract]
public class A {
public A(){}
[DataMember]
public bool IsActive {get;set;]
[DataMember]
public int VersionNumber {
get { return 1; }
set { }
}
[DataMember]
public int TimeInSeconds {get;set;}
[DataMember]
public string Name {get;set;}
[DataMember]
public CustomObject CustomObj {get;set;} //Also a DataContract
[DataMember]
public List<ComplexThing> ComplexThings {get;set;} //Also a DataContract
...
}
[DataContract]
public class B {
public B(A a) {
this.Enabled = a.IsActive; //Property now has a different name
this.TimeInMilliseconds = a.TimeInSeconds * 1000; //Property requires math for correctness
this.Name = a.Name;
this.CustomObject2 = new CustomObject2(a.CustomObj); //Reference objects change, too
this.ComplexThings = new List<ComplexThings>();
this.ComplexThings.AddRange(a.ComplexThings);
...
}
public B(){}
[DataMember]
public bool Enabled {get;set;]
[DataMember]
public int Version {
get { return 2; }
set { }
}
[DataMember]
public double TimeInMilliseconds {get;set;}
[DataMember]
public string Name {get;set;}
[DataMember]
public CustomObject2 CustomObject {get;set;} //Also a DataContract
[DataMember]
public List<ComplexThing> ComplexThings {get;set;} //Also a DataContract
...
}
Class A was the first iteration of our object, and is actively in use. Data exists in v1 format, using class A for serialization.
After realizing the error of our ways, we create a new structure called class B. There are so many changes between A and B that we feel it's better to create B, as opposed to adapting the original class A.
But our application already exists and class A is being used to serialize data. We're ready to roll our changes out to the world, but we must first deserialize data created under version 1 (using class A) and instantiate it as class B. The data is significant enough that we can't just assume defaults in class B for missing data, but rather we must transition the data from a class A instance to class B. Once we have a class B instance, the application will serialize that data again in class B format (version 2).
We're assuming we'll make modifications to class B in the future, and we want to be able to iterate to a version 3, perhaps in a new class "C". We have two goals: address data already in existence, and prepare our objects for future migration.
The existing "transition" attributes (OnSerializing/OnSerialized,OnDeserializing/OnDeserialized,etc.) don't provide access to the previous data.
What is the expected practice when using protobuf-net in this scenario?

Right; looking at them you have indeed completely changed the contract. I know of no contract-based serializer that is going to love you for that, and protobuf-net is no different. If you already had a root node, you could do something like (in pseudo-code):
[Contract]
class Wrapper {
[Member] public A A {get;set;}
[Member] public B B {get;set;}
[Member] public C C {get;set;}
}
and just pick whichever of A/B/C is non-null, perhaps adding some conversion operators between them. However, if you just have a naked A in the old data, this gets hard. There are two approaches I can think of:
add lots of shim properties for compatibility; not very maintainable, and I don't recommend it
sniff the Version as an initial step, and tell the serializer what to expect.
For example, you could do:
int version = -1;
using(var reader = new ProtoReader(inputStream)) {
while(reader.ReadFieldHeader() > 0) {
const int VERSION_FIELD_NUMBER = /* todo */;
if(reader.FieldNumber == VERSION_FIELD_NUMBER) {
version = reader.ReadInt32();
// optional short-circuit; we're not expecting 2 Version numbers
break;
} else {
reader.SkipField();
}
}
}
inputStream.Position = 0; // rewind before deserializing
Now you can use the serializer, telling it what version it was serialized as; either via the generic Serializer.Deserialize<T> API, or via a Type instance from the two non-generic APIs (Serializer.NonGeneric.Deserialize or RuntimeTypeModel.Default.Deserialize - either way, you get to the same place; it is really a case of whether generic or non-generic is most convenient).
Then you would need some conversion code between A / B / C - either via your own custom operators / methods, or by something like auto-mapper.
If you don't want any ProtoReader code kicking around, you could also do:
[DataContract]
class VersionStub {
[DataMember(Order=VERSION_FIELD_NUMBER)]
public int Version {get;set;}
}
and run Deserialize<VersionStub>, which will give you access to the Version, which you can then use to do the type-specific deserialize; the main difference here is that the ProtoReader code allows you to short-circuit as soon as you have a version-number.

I don't have an expected practice, but this is what I'd do.
Given you still have access to your V1 class add a property on your V1 class that provides a V2 instance.
In your ProtoAfterDeserialization of V1 create an instance of V2 and seeing it's a Migration I'd suggest manually transfer across what you need (or if it's not too hard, try Merge YMMV).
Also in your ProtoBeforeSerialization throw some form of exception so that you don't attempt to write out the old one any more.
Edit: Examples of using these (VB code)
<ProtoBeforeSerialization()>
Private Sub BeforeSerialisaton()
End Sub
<ProtoAfterSerialization()>
Private Sub AfterSerialisaton()
End Sub
<ProtoBeforeDeserialization()>
Private Sub BeforeDeserialisation()
End Sub
<ProtoAfterDeserialization()>
Private Sub AfterDeserialisation()
End Sub
after seeing your example I hope this satisfied what you are trying to do. Class1 is how you load/convert.
using ProtoBuf;
using System.Collections.Generic;
using System.IO;
public class Class1
{
public Class1()
{
using (FileStream fs = new FileStream("c:\\formatADataFile.dat",
FileMode.Open, FileAccess.Read))
{
A oldA = Serializer.Deserialize<A>(fs);
B newB = oldA.ConvertedToB;
}
}
}
[ProtoContract()]
public class B
{
public B(A a)
{
//Property now has a different name
this.Enabled = a.IsActive;
//Property requires math for correctness
this.TimeInMilliseconds = a.TimeInSeconds * 1000;
this.Name = a.Name;
//Reference objects change, too
this.CustomObject2 = new CustomObject2(a.CustomObj);
this.ComplexThings = new List<ComplexThings>();
this.ComplexThings.AddRange(a.ComplexThings);
//...
}
public B() { }
//[DataMember]
[ProtoMember(1)]
public bool Enabled { get; set; }
//[DataMember]
public int Version
{
get { return 2; }
private set { }
}
[ProtoMember(2)]
public double TimeInMilliseconds { get; set; }
[ProtoMember(3)]
public string Name { get; set; }
[ProtoMember(4)]
public CustomObject2 CustomObject { get; set; } //Also a DataContract
[ProtoMember(5)]
public List<ComplexThing> ComplexThings { get; set; } //Also a DataContract
///...
}
[ProtoContract()]
public class CustomObject2
{
public CustomObject2()
{
Something = string.Empty;
}
[ProtoMember(1)]
public string Something { get; set; }
}
[ProtoContract()]
public class A
{
public A()
{
mBConvert = new B();
}
[ProtoMember(1)]
public bool IsActive { get; set; }
[ProtoMember(2)]
public int VersionNumber
{
get { return 1; }
private set { }
}
[ProtoBeforeSerialization()]
private void NoMoreSavesForA()
{
throw new System.InvalidOperationException("Do Not Save A");
}
private B mBConvert;
[ProtoAfterDeserialization()]
private void TranslateToB()
{
mBConvert = new B(this);
}
public B ConvertedToB
{
get
{
return mBConvert;
}
}
[ProtoMember(3)]
public int TimeInSeconds { get; set; }
[ProtoMember(4)]
public string Name { get; set; }
[ProtoMember(5)]
public CustomObject CustomObj { get; set; } //Also a DataContract
[ProtoMember(6)]
public List<ComplexThing> ComplexThings { get; set; } //Also a DataContract
//...
}
[ProtoContract()]
public class CustomObject
{
public CustomObject()
{
}
[ProtoMember(1)]
public int Something { get; set; }
}
[ProtoContract()]
public class ComplexThing
{
public ComplexThing()
{
}
[ProtoMember(1)]
public int SomeOtherThing { get; set; }
}