C#

private void Window_Loaded( object sender, RoutedEventArgs e ) {

   _blinkTimer = new DispatcherTimer();
   _blinkTimer.Tick += timer_Tick;
   _blinkTimer.Interval = new TimeSpan( 0, 0, 0, 0, 500 );
   _blinkTimer.Start();
}

private void timer_Tick( object sender, EventArgs e ) {

   if ( _blinkToggle ) {
      uxWarningText.Foreground = Brushes.Black;
      uxWarningText.Background = Brushes.White;

   } else {
      if ( this.ZoneWarnings.Count > 0 ) {
         uxWarningText.Foreground = Brushes.White;
         uxWarningText.Background = Brushes.Red;
      }
   }

   _blinkToggle = !_blinkToggle;
}

DoSomething(myobj).DoSomethingElse();

myObj.DoSomething().DoSomethingElse();

DateTime expiry = DateTime.Now.Date.AddYears(1).AddDays(1);

DateTime expiry = DateTime.Now;
expiry.Date(out expiry);
expiry.AddYears(1, out expiry);
expiry.AddDays(1, out expiry);

public class SomeObj
{
    public string SomeParam { get; set; }

    public int Id { get; }

    public Dictionary<string, DateTime> ParamLog { get; set; }

    public SomeObj(string sparam, int id)
    {
        SomeParam = sparam;

        Id = id;

        ParamLog =  new Dictionary<string, DateTime> {{sparam, DateTime.Now}};
    }
}

public static class SomeObjExtensions
{
    public static SomeObj SetSomeParam(this SomeObj obj, string newsparam)
    {
        if (obj.SomeParam.Equals(newsparam)) return obj;

        obj.SomeParam = newsparam;
        obj.ParamLog.Add(newsparam, DateTime.Now);

        return obj;
    }

    public static SomeObj Clone(this SomeObj obj, string newsparam)
    {
        var newobj = new SomeObj(newsparam, obj.Id);

        // see note below
        newobj.ParamLog = new Dictionary<string, DateTime>(obj.ParamLog);

        return newobj;
    }

}

BillWoodruff wrote:

I think it imperative to think carefully about when, how, and where, any Class instance may be modified.

BillWoodruff wrote:

I am inclined, now, to do without 'ref and 'out,

BillWoodruff wrote:

to think about the issue of "immutability" ... F# enforces that strictly.

BillWoodruff wrote:

With a very complex Class,

public class POCOLocoTuple
{
    public POCOLocoTuple()
    {
    }

    public POCOLocoTuple(string name, int age)
    {
        PBag = (Guid.NewGuid(), name, age);
    }

    private (Guid Id, string Name, int Age) PBag { set; get; }

    public string Name
    {
        set
        {
            PBag = (PBag.Id, value, PBag.Age);
        }
    }

    public int Age
    {
        set
        {
            PBag = (PBag.Id, PBag.Name, value);
        }
    }

    public POCOLocoTuple Clone(bool makenewguid = true)
    {
        Guid guid = makenewguid ? Guid.NewGuid() : PBag.Id;

        POCOLocoTuple newpocoloco = new POCOLocoTuple();

        newpocoloco.PBag = (guid, PBag.Name, PBag.Age);

        return newpocoloco;
    }
}

BillWoodruff wrote:

Perhaps you are suggesting using Tuples with multiple Types like a property-bag ?

BillWoodruff wrote:

I can't quite see how F# would, inherently, remove a need to have complex POCOS: if a POCO gotta have a lotta fields or properties

class BirthDate
{
  public int Month {get;set;}
  public int Day {get;set;}
  public int Year {get;set;}
}

class Horoscope
{
  public string GetHoroscope(BirthDate date);
  // Alternatively:
  public string GetHoroscope(int y, int m, int d);
}

let curried1 = GetHoroscope PromptForYear
let curried2 = curried1 PromptForMonth
let text = curried2 PromptForDay

SomeObj myobj = new SomeObj ( someparam = "Some Value" );
myobj = DoSomething( myobj );

var stuffWorkflowNeedsToKnow = InitializeStuff();
DoStep1(stuffWorkflowNeedsToKnow);
DoStep2(stuffWorkflowNeedsToKnow);
DoStep3(stuffWorkflowNeedsToKnow);

Quote:

Where it's ok to ask questions that haven't been thoroughly researched?
Where you don't get downvoted because a question has been asked before (because every question has)?