C#

apadana_1989 wrote:

how can i connect and disconnect to internet by exist connection in the c# ?

public ObservableCollection<int> CountAdvanceCurve
       {
           get { return _countAdvanceCurve; }
           set { _countAdvanceCurve = value; }
       }

public Dictionary<int,int> CountAdvanceCurve
        {
            get { return _countAdvanceCurve; }
            set { _countAdvanceCurve = value; }
        }

public Dictionary<string, int> LowValues
    {
    get
        {
        Dictionary<string, int> dict = new Dictionary<string, int>();
        if (_countAdvanceCurve < 1000) dict.Add("AdvanceCurve", _countAdvanceCurve);
        if (_countAdvancesSBCAgencyCurve < 1000) dict.Add("AdvancesSBCAgencyCurve", _countAdvancesSBCAgencyCurve);
        if (_countAdvancesSBCAAACurve < 1000) dict.Add("AdvancesSBCAAACurve", _countAdvancesSBCAAACurve);
        if (_countFhlbsfTreasuryCurve < 1000) dict.Add("FhlbsfTreasuryCurve", _countFhlbsfTreasuryCurve);
        if (_countDNCOCurve < 1000) dict.Add("DNCOCurve", _countDNCOCurve);
        return dict;
        }
    }

private List<string> _curveswithnodata = new List<string>();

       public List<string> Curveswithnodata
       {
           get { return _curveswithnodata; }
           set { _curveswithnodata = value; }
       }

private List<string> _curveswithnodata = new List<string>();

public List<string> Curveswithnodata
    {
    get { return new List<string>(_curveswithnodata); }
    set { _curveswithnodata = value; }
    }

get { return _curveswithnodata.AsReadOnly());

Alan N wrote:

don't do anything naughty

public abstract class MyBase
{
  public MyBase()
  {
    Initialize();
  }

  private void Initialize()
  {
    OnInitialize();
  }

  protected virtual void OnInitialize()
  {
  }
}

contains a call chain that results in a call to a virtual method defined by the class

DaveyM69 wrote:

The overridden method is purely setting instance fields unique to that class to
their initial values (these are not changed anywhere after instanciation - that
part of the derived classes is immutable) and returning initialization values
that are common to all derived classes to the base's constructor.

jschell wrote:

why would the base ctor care about child initialization values when all the base
ctor should be doing is initializing the base ctor

public abstract class Base
{
    private int commonValue1;
    private int commonValue2;
    private int id;

    protected Base(int id)
    {
        this.id = id;
        Initialize(out commonValue1, out commonValue2); // CA2214
    }

    public int CommonValue1
    {
        get { return commonValue1; }
    }
    public int CommonValue2
    {
        get { return commonValue2; }
    }
    public int Id
    {
        get { return id; }
    }

    protected abstract void Initialize(out int commonValue1, out int commonValue2);
}

public class ChildA : Base
{
    public ChildA(int id)
        : base(id)
    { }

    protected override void Initialize(out int commonValue1, out int commonValue2)
    {
        DataA data;
        NativeMethods.UnmanagedFunctionGetChildAData(Id, out data);
        commonValue1 = data.Value1;
        commonValue2 = data.Value2;
    }
}

public class ChildB : Base
{
    private int childBValue;

    public ChildB(int id)
        : base(id)
    { }

    public int ChildBValue { get { return childBValue; } }

    protected override void Initialize(out int commonValue1, out int commonValue2)
    {
        DataB data;
        NativeMethods.UnmanagedFunctionGetChildBData(Id, out data);
        commonValue1 = data.Value1;
        commonValue2 = data.Value2;
        childBValue = data.Value3;
    }
}

public class ChildC : Base
{
    private int childCValue1;
    private int childCValue2;

    public ChildC(int id)
        : base(id)
    { }

    public int ChildCValue1 { get { return childCValue1; } }
    public int ChildCValue2 { get { return childCValue2; } }

    protected override void Initialize(out int commonValue1, out int commonValue2)
    {
        DataC data;
        NativeMethods.UnmanagedFunctionGetChildCData(Id, out data);
        commonValue1 = data.Value1;
        commonValue2 = data.Value2;
        childCValue1 = data.Value3;
        childCValue2 = data.Value4;
    }
}

[StructLayout(LayoutKind.Sequential)]
internal struct DataA
{
    private int value1;
    private int value2;

    public int Value1 { get { return value1; } }
    public int Value2 { get { return value2; } }
}

[StructLayout(LayoutKind.Sequential)]
internal struct DataB
{
    private int value1;
    private int value2;
    private int value3;

    public int Value1 { get { return value1; } }
    public int Value2 { get { return value2; } }
    public int Value3 { get { return value3; } }
}

[StructLayout(LayoutKind.Sequential)]
internal struct DataC
{
    private int value1;
    private int value2;
    private int value3;
    private int value4;

    public int Value1 { get { return value1; } }
    public int Value2 { get { return value2; } }
    public int Value3 { get { return value3; } }
    public int Value4 { get { return value4; } }
}

internal static class NativeMethods
{
    // this methods are just simulating the unmanaged functions that retrieve filled DataA/DataB/DataC
    public static void UnmanagedFunctionGetChildAData(int id, out DataA data)
    {
        data = new DataA();
    }
    public static void UnmanagedFunctionGetChildBData(int id, out DataB data)
    {
        data = new DataB();
    }
    public static void UnmanagedFunctionGetChildCData(int id, out DataC data)
    {
        data = new DataC();
    }
}

DaveyM69 wrote:

Perhaps this code will make it clearer...

jschell wrote:

based members protected

jschell wrote:

protected setter for those members