将自定义类型发送到 DLL

Question

I have created a custom type (StampDates) that consist of an InDate and an OutDate A List of these objects is sent to a dll that does some math on it, and return a value.For now, this is just 1 set of dates, but I will send filled Lists, and the dll will return a sum of them all.

The method in the dll expects a list of the type <StampDates> :

public int NumDays(List<StampDates> dates)
{
    foreach (StampDates datums in dates)
    {
        DateTime indatum = datums.InDateTime;
        DateTime uitdatum = datums.OutDateTime;
        if ((DateTime.Now.Date - indatum).TotalDays <= 180)
        {
            Days = (uitdatum-indatum  ).Days;
        }

    }

    return Days;
}

This works fine, but because I need to create that list in my external form, I need to define the custom type there also. This gives a type conversion error between the Form.StampDates and the DLL.Stampdates

public class StampDates
{
    private DateTime inDateTime;

    public DateTime InDateTime
    {
        get { return inDateTime; }
        set { inDateTime = value; }
    }

    private DateTime outDateTime;

    public DateTime OutDateTime
    {
        get { return outDateTime; }
        set { outDateTime = value; }
    }
}

How can I solve this?

Answer 1

I would recommend the usage of interfaces here:

DLL:

// In the dll we do not care about the actual implementation.
// To perform our task, we just need this to have two properties:
public interface IStampDates 
{
    // Implementations must have these read/write properties
    DateTime InDateTime {get; set;}  // We even could make those readonly ...
    DateTime OutDateTime {get; set;}
}

// in the class that contains the method ...
public int NumDays(IEnumerable<IStampDates> dates)
{
      // Implementation has no dependency other than dotnet framework (for IEnumerable)
}

In the consuming App:

// Implementation of the IStampDates interface
class StampDates : IStampDates
{
    public DateTime InDateTime {get; set;}
    public DateTime OutDateTime {get; set;}
}

// Consuming part somewhere in a method, perhaps
List<IStampDates> stampDateList = new List<IStampDates>();
// ... populate list
stampDateList.Add( new StampDates() { InDateTime = ..., OutDatTime = ... });

// Call Dll
int days = dll.NumDays(stampDateList);
// assuming "dll" is an instance of the class that contains `NumDays`

So, your App has a dependency to the dll. That's fine. But your dll has no dependency outside itself or the framework (which is kind of unavoidable). That means: if you use this dll in another App, the actual implementation of StampDates can be totally different, as long as it implements the Dll's interface of IStampDates .

The point of this being: If you use an interface here, it doesn't matter what the actual runtime type it is you are passing (given, it implements the interface). So it could be defined in the App, in the dll (the app should then use it, not create a (code)copy) or even in a third shared dependency. All depends on how you structure your solution.