Sealable and Unsealable modifiers for each property

[ststeiger]

A modifier sealable and unsealable for properties.
So that I can make them ReadOnly AT RUNTIME.
Plus the possiblity to set all properties of a class instance to ReadOnly AT ONCE (at runtime).
And the optional (aka programmer configurable) ability to undo that, should it ever be needed (at runtime).

Basically, like Object.freeze() in JavaScript.

UseCase:
Fetch CacheData from SQL with Dapper: connection.Query("SELECT * FROM config_table");
CacheData.SealAll(); // so no property can accidentally (or intentionally) be modified by the developer
put catchData into a lookup-structure with a ReaderWriterLockSlim

namespace CSharp.LanguageProposal.SealedUnsealed
{


    public class CacheData
    {

        private bool m_isSealed = false; // Flag to lock the object
        private readonly System.InvalidOperationException m_modifyDisallowed;


        public CacheData()
        {
            this.m_isSealed = false;
            this.m_modifyDisallowed = new System.InvalidOperationException("You are not allowed to modify cached values.");
        }




        private int m_value1;
        public int Value1
        {
            get { return this.m_value1; }
            set
            {
                if (this.m_isSealed)
                {
                    throw m_modifyDisallowed;
                }

                this.m_value1 = value;
            }
        }


        private int m_value2;
        public int Value2
        {
            get { return this.m_value2; }
            set
            {
                if (this.m_isSealed)
                {
                    throw m_modifyDisallowed;
                }

                this.m_value2 = value;
            }
        }


        public void Seal()
        {
            this.m_isSealed = true;
        }


    } // End Class CacheData 




    public class CacheAccessor<T>
        : System.IDisposable
    {

        private readonly T m_cache;
        private readonly System.Threading.ReaderWriterLockSlim m_rwLock;


        public CacheAccessor(T cacheData, System.Threading.ReaderWriterLockSlim rwLock)
        {
            this.m_cache = cacheData;
            this.m_rwLock = rwLock; ;
        } // End Constructor 


        public T Data
        {
            get
            {
                return this.m_cache;
            }

        } // End Property Data


        void System.IDisposable.Dispose()
        {
            this.m_rwLock.ExitReadLock();
        } // End Interface IDisposable.Dispose


    } // End Class CacheAccessor<T>


    public class Cache
    {
        private readonly System.Threading.ReaderWriterLockSlim m_rwLock;
        private System.DateTime m_lastUpdated;
        private CacheData m_cachedData;


        private Cache()
        {
            this.m_rwLock = new System.Threading.ReaderWriterLockSlim();
            // System.Threading.Tasks.Task.Run(async delegate() {  _ = CheckAndRefreshAsync(); });
        } // End Constructor 


        public static async System.Threading.Tasks.Task<Cache> CreateAsync()
        {
            Cache newInstance = new Cache();
            CacheData initialData = await newInstance.FetchCacheDataFromDbAsync();
            newInstance.UpdateChache(initialData);
            _ = newInstance.CheckAndRefreshAsync();

            return newInstance;
        } // End Task CreateAsync 


        public int Value1
        {
            get
            {
                this.m_rwLock.EnterReadLock();

                try
                {
                    return this.m_cachedData.Value1;
                } // End Try 
                finally
                {
                    this.m_rwLock.ExitReadLock();
                } // End finally 

            } // End Get 

        } // End Property Value1 


        public CSharp.LanguageProposal.SealedUnsealed.CacheAccessor<CacheData> EntireCache
        {
            get
            {
                this.m_rwLock.EnterReadLock();

                try
                {

                    CacheAccessor<CacheData> cd = new CacheAccessor<CacheData>(this.m_cachedData, this.m_rwLock);
                    return cd;
                } // End Try 
                catch (System.Exception ex)
                {
                    this.m_rwLock.ExitReadLock();
                    throw;
                }

            } // End Getter 

        } // End Property EntireCache 


        private async System.Threading.Tasks.Task<CacheData> FetchCacheDataFromDbAsync()
        {
            CacheData ret = new CacheData() { Value1 = 123, Value2 = 456 };
            ret.Seal();
            return await System.Threading.Tasks.Task.FromResult(ret);
        } // End Task FetchCacheDataFromDbAsync 


        private void UpdateChache(CacheData newValue)
        {
            this.m_rwLock.EnterWriteLock();

            try
            {
                this.m_cachedData = newValue;
                this.m_lastUpdated = System.DateTime.UtcNow;
            } // End Try 
            finally
            {
                this.m_rwLock.ExitWriteLock();
            } // End Finally 
        } // End Task UpdateChache


        public bool HasChanges(CacheData newData)
        {
            if (this.m_cachedData.Value1 != newData.Value1)
                return true;

            if (this.m_cachedData.Value2 != newData.Value2)
                return true;

            return false;
        }


        private async System.Threading.Tasks.Task CheckAndRefreshAsync()
        {
            while (true)
            {
                await System.Threading.Tasks.Task.Delay(System.TimeSpan.FromHours(1));

                CacheData newData = await FetchCacheDataFromDbAsync();
                if (HasChanges(newData))
                {
                    UpdateChache(newData);
                } // End if(this.m_cachedValue != newData)

            } // Whend 

        } // End Task CheckAndRefreshAsync 


        internal static async System.Threading.Tasks.Task Test()
        {
            CSharp.LanguageProposal.SealedUnsealed.Cache cache = await CSharp.LanguageProposal.SealedUnsealed.Cache.CreateAsync();

            System.Console.WriteLine(cache.Value1);


            using (CSharp.LanguageProposal.SealedUnsealed.CacheAccessor<CSharp.LanguageProposal.SealedUnsealed.CacheData> accessor = cache.EntireCache)
            { // Why is there no scope-interface for an action at the beginning of a scope, like System.IDisposable.Dispose ? 
                System.Console.WriteLine(accessor.Data.Value1);
                try
                {
                    accessor.Data.Value1 = 9876;
                }
                catch (System.Exception ex)
                {
                    System.Console.WriteLine(ex.Message);
                    System.Console.WriteLine(ex.StackTrace);
                }

                try
                {
                    accessor.Data.Value2 = 9876;
                }
                catch (System.Exception ex)
                {
                    System.Console.WriteLine(ex.Message);
                    System.Console.WriteLine(ex.StackTrace);
                }

            }

            System.Console.WriteLine(cache.Value1);


            using (CSharp.LanguageProposal.SealedUnsealed.CacheAccessor<CSharp.LanguageProposal.SealedUnsealed.CacheData> accessor = cache.EntireCache)
            {
                System.Console.WriteLine(accessor.Data.Value1);
                accessor.Data.Value1 = 9876;
            } // End Using accessor 

        } // End Task Test 


    } // End Class Cache 


} // End Namespace 

[bernd5]

You can achieve runtime-sealing with a custom source generator (partial properties with generated check code). To identify them you can add an attribute like "RuntimeSealedAttribute".

[ststeiger]

You can achieve runtime-sealing with a custom source generator (partial properties with generated check code). To identify them you can add an attribute like "RuntimeSealedAttribute".

Yea, source generator is exactly what i don't want.
Then I need to write those horrible constructs for each property.
It's bad enough I need to use property because Dapper wants so.

[bernd5]

What horrible constructs?

The user code could look like:

using System;
using RS = RuntimeSealedAttribute;

public partial class CacheData
{
    [RS]
    public partial int Value1 {get; set;}

    [RS]
    public partial int Value2 {get; set;}
}

And the source generator could generate:

public partial class CacheData
{
    private bool m_isSealed;
    private int m_value1;
    
    private void CheckSealed()
    {
        if (this.m_isSealed)
        {
            throw new System.InvalidOperationException("You are not allowed to modify cached values.");
        }
    }
    
    public partial int Value1
    {
        get { return this.m_value1; }
        set
        {
            CheckSealed();
            this.m_value1 = value;
        }
    }


    private int m_value2;
    public partial int Value2
    {
        get { return this.m_value2; }
        set
        {
            CheckSealed();
            this.m_value2 = value;
        }
    }

    public void Seal()
    {
        this.m_isSealed = true;
    }
}

with the library code (to identify the properties - but you could rely on naming conventions, too):

public class RuntimeSealedAttribute : Attribute{ }

[bernd5]

The rest of the code looks quite strange in my eyes, e.g.:

 get
            {
                this.m_rwLock.EnterReadLock();

                try
                {

                    CacheAccessor<CacheData> cd = new CacheAccessor<CacheData>(this.m_cachedData, this.m_rwLock);
                    return cd;
                } // End Try 
                catch (System.Exception ex)
                {
                    this.m_rwLock.ExitReadLock();
                    throw;
                }

            } // End Getter 

You should use try-finally for the lock or use the lock keyword (see lock-object-proposal).

The presented code leaks a read-lock when no exception is raised...

[bernd5]

To understand you better, please format your code and mark it with "csharp".

In markdown you can write:

```csharp
using System;

class Foo{
  //what ever...
}
```

In addition make your code samples as small as possible.

[ststeiger]

You should use try-finally for the lock or use the lock keyword (see lock-object-proposal).

Incorrect, if you do it in the finally-block, it will also unlock the rw-lock instantaneously, which is wrong.

The idea is that you access the cache data (with r-lock), then access a few values, then exit the r-lock when finished using cache values.

using(var CacheData = accessor.Data) // locking in the constuctor is wrong 
{// here it needs to lock 
   // do something with CacheData.Value1 
   // do something with CacheData.Value2 
  // ... 
   // do something with CacheData.ValueN 
} // Here it needs to unlock 

because an unaware developer could also do that:

var CacheData = accessor.Data; // this is why locking in the constructor is wrong 
// it will automatically lock in the above line, but the programmer knows nothing about it 
// it will work, because it has the r-lock 
// but the update will no longer work, because the r-lock never is released. 
// ****** then, next time a w-lock is attempted to take, it will most likely block the entire application ******

// here not do a read-lock  - which must be prevented 
   DoSomethingWith(CacheData.Value1 );
   DoSomethingWith(CacheData.Value2 );
   // ... 
   DoSomethingWith(CacheData.ValueN );
// here not do an unlock of the read-lock  - which must be prevented as well 
// also, if you do proper locking and unlocking, but not in try-finally, it will also explode in your face really quick 

ideally, it would be possible to entirely deny using accessor.Data without using clause, because if the block is not in a try-finally, then it will screw the entire application up, as the cache will never get refreshed.

[CyrusNajmabadi]

Incorrect, if you do it in the finally-block, it will also unlock the rw-lock instantaneously, which is wrong.

That's not the case. It will unlock when the block is left. Try/catch is incorrect here. You should use try/finally

[ststeiger]

yrusNajmabadi Sep 11, 2024

Absolutely not, it should absolutely not release the r-lock right after the wrapper is returned.
It should only release the r-lock once the wrapper is no longer used, that is to say, after it is disposed.
If you put it into finally, it will unlock immediately, which is wrong.
It should only unlock if there's an error inside the constructor.

[CyrusNajmabadi]

The accessor constructor can't fail here afaict. Perhaps on Netflix with a thread abort. But you're hosed in that case anyways.