public Task AddAsync <TYPE>(string key, TYPE data)
{
if (data == null)
{
#if MVC6
YetaWFManager.MemoryCache.Set <object>(key, EmptyCachedObject);
#else
System.Web.HttpRuntime.Cache[key] = EmptyCachedObject;
#endif
}
else
{
// we can't save the entire object, just the data that we actually marked as savable (Properties)
// the main reason the object is not savable is because it may be derived from other classes with
// volatile data which is expected to be cleared for every invocation.
byte[] cacheData;
if (typeof(TYPE) == typeof(byte[]))
{
cacheData = (byte[])(object)data;
}
else
{
cacheData = new GeneralFormatter().Serialize(data);
}
#if MVC6
YetaWFManager.MemoryCache.Set <byte[]>(key, cacheData);
#else
System.Web.HttpRuntime.Cache[key] = cacheData;
#endif
}
return(Task.CompletedTask);
}
internal string GetPercentageText(double?value)
{
if (!value.HasValue)
{
return(string.Empty);
}
IFormatter actualFormatter = this.ActualFormatter;
if ((actualFormatter == null) || ((actualFormatter != null) && (actualFormatter.FormatString == "General")))
{
actualFormatter = new GeneralFormatter("0%");
}
return(actualFormatter.Format(value));
}
static void UpdateFormatter(string text, Cell cell, Type cacheValueType)
{
object obj2 = null;
GeneralFormatter preferredDisplayFormatter = new GeneralFormatter().GetPreferredDisplayFormatter(text, out obj2) as GeneralFormatter;
object obj3 = obj2;
if (((cell.ActualFormatter != null) && (obj2 != null)) && ((cell.ActualFormatter is AutoFormatter) && !preferredDisplayFormatter.FormatString.Equals("General")))
{
cell.Formatter = new AutoFormatter(preferredDisplayFormatter);
}
else if (cell.ActualFormatter == null)
{
cell.Formatter = new AutoFormatter(preferredDisplayFormatter);
}
cell.Value = obj3;
}
/// <summary>
/// Gets the valid list.
/// </summary>
/// <param name="evaluator">The evaluator.</param>
/// <param name="baseRow">The base row.</param>
/// <param name="baseColumn">The base column.</param>
/// <returns>The valid list.</returns>
public object[] GetValidList(ICalcEvaluator evaluator, int baseRow, int baseColumn)
{
List <object> list = new List <object>();
if (!string.IsNullOrEmpty(base.ExpectedFormula))
{
object obj2 = base.GetExpected(evaluator, baseRow, baseColumn, true);
if (obj2 is Array)
{
IEnumerator enumerator = (obj2 as Array).GetEnumerator();
while (enumerator.MoveNext())
{
list.Add(enumerator.Current);
}
}
else
{
list.Add(obj2);
}
}
else if (!string.IsNullOrEmpty((string)(base.ExpectedValue as string)))
{
string expectedValue = (string)(base.ExpectedValue as string);
string listSeparator = CultureInfo.InvariantCulture.TextInfo.ListSeparator;
string[] strArray = new string[] { listSeparator, ((char)this.ExpressionListSeparator).ToString() };
string[] strArray2 = expectedValue.Split(strArray, (StringSplitOptions)StringSplitOptions.None);
if (strArray2 != null)
{
GeneralFormatter formatter = new GeneralFormatter();
foreach (string str3 in strArray2)
{
if ((str3 != null) && !(str3 == string.Empty))
{
string str = str3.Trim(new char[] { DefaultTokens.Space });
if ((str != null) && (str != string.Empty))
{
list.Add(formatter.Parse(str));
}
}
}
}
}
return(list.ToArray());
}
public Task <GetObjectInfo <TYPE> > GetAsync <TYPE>(string key)
{
object data = null;
#if MVC6
data = YetaWFManager.MemoryCache.Get(key);
#else
data = System.Web.HttpRuntime.Cache[key];
#endif
if (data != null)
{
if (data.GetType() == typeof(string) && (string)data == EmptyCachedObject)
{
return(Task.FromResult(new GetObjectInfo <TYPE> {
Data = default(TYPE),
Success = true,
}));
}
else
{
TYPE desData;
if (typeof(TYPE) == typeof(byte[]))
{
desData = (TYPE)data;
}
else
{
desData = new GeneralFormatter().Deserialize <TYPE>((byte[])data);
}
return(Task.FromResult(new GetObjectInfo <TYPE> {
Data = (TYPE)desData,
Success = true,
}));
}
}
else
{
return(Task.FromResult(new GetObjectInfo <TYPE>()));
}
}
// API
/// <summary>
/// Add a shared object.
/// </summary>
/// <remarks>This requires an active Lock using a lock provider.</remarks>
public async Task AddAsync <TYPE>(string key, TYPE data)
{
key = KeyPrefix + key;
key = GetKey(key);
// save new version shared and locally
byte[] cacheData = new GeneralFormatter().Serialize(data);
DateTime created = DateTime.UtcNow;
IDatabase db = Redis.GetDatabase();
if (YetaWFManager.IsSync())
{
db.KeyDelete(GetVersionKey(key));
db.KeyDelete(GetDataKey(key));
db.StringSet(GetVersionKey(key), created.Ticks);
db.StringSet(GetDataKey(key), cacheData);
}
else
{
await db.KeyDeleteAsync(GetVersionKey(key));
await db.KeyDeleteAsync(GetDataKey(key));
await db.StringSetAsync(GetVersionKey(key), created.Ticks);
await db.StringSetAsync(GetDataKey(key), cacheData);
}
StaticCacheObject cachedObj = new StaticCacheObject {
Key = key,
Value = data,
Created = created,
};
lock (_lockObject) { // used to protect StaticObjects - local only
StaticObjects.Remove(key);
StaticObjects.Add(key, cachedObj);
}
}
private ExcelDbType GetFormatType(string numberFormat)
{
GeneralFormatter generalFormatter = new GeneralFormatter(numberFormat);
switch (generalFormatter.FormatType)
{
case NumberFormatType.General:
return(ExcelDbType.String);
case NumberFormatType.Number:
return(ExcelDbType.Double);
case NumberFormatType.DateTime:
return(ExcelDbType.DateTime);
case NumberFormatType.Text:
return(ExcelDbType.String);
default:
return(ExcelDbType.String);
}
}
// API
public async Task AddAsync <TYPE>(string key, TYPE data)
{
// save new version shared and locally
byte[] cacheData = new GeneralFormatter().Serialize(data);
SharedCacheObject sharedCacheObj = new SharedCacheObject {
Created = DateTime.UtcNow,
Key = key,
Value = cacheData,
};
await DataProvider.RemoveAsync(key);
await DataProvider.AddAsync(sharedCacheObj); // save shared cached version
LocalSharedCacheObject localCacheObj = new LocalSharedCacheObject {
Created = sharedCacheObj.Created,
Key = sharedCacheObj.Key,
Value = sharedCacheObj.Value,
};
using (ICacheDataProvider localCacheDP = YetaWF.Core.IO.Caching.GetLocalCacheProvider()) {
await localCacheDP.AddAsync(key, localCacheObj); // save locally cached version
}
}
// API
public async Task AddAsync <TYPE>(string key, TYPE data)
{
key = KeyPrefix + key;
// save new version shared and locally
byte[] cacheData = new GeneralFormatter().Serialize(data);
DateTime created = DateTime.UtcNow;
IDatabase db = Redis.GetDatabase();
if (YetaWFManager.IsSync())
{
db.KeyDelete(GetVersionKey(key));
db.KeyDelete(GetDataKey(key));
db.StringSet(GetVersionKey(key), created.Ticks);
db.StringSet(GetDataKey(key), cacheData);
}
else
{
await db.KeyDeleteAsync(GetVersionKey(key));
await db.KeyDeleteAsync(GetDataKey(key));
await db.StringSetAsync(GetVersionKey(key), created.Ticks);
await db.StringSetAsync(GetDataKey(key), cacheData);
}
LocalSharedCacheObject localCacheObj = new LocalSharedCacheObject {
Created = created,
Key = key,
Value = cacheData,
};
using (ICacheDataProvider localCacheDP = YetaWF.Core.IO.Caching.GetLocalCacheProvider()) {
await localCacheDP.AddAsync(key, localCacheObj); // save locally cached version
}
}
public async Task <GetObjectInfo <TYPE> > GetAsync <TYPE>(string key)
{
// get cached version
TYPE data = default(TYPE);
key = GetKey(key);
StaticCacheObject cachedObj;
bool localValid;
lock (_lockObject) { // used to protect StaticObjects - local only
localValid = StaticObjects.TryGetValue(key, out cachedObj);
}
if (!localValid)
{
cachedObj = new StaticCacheObject {
Key = key,
Value = default(TYPE),
Created = DateTime.MinValue,
};
}
else
{
data = (TYPE)cachedObj.Value;
}
// get shared cached version
SharedCacheVersion sharedInfo = await SharedCacheVersionPostgreSQLDataProvider.SharedCacheVersionDP.GetVersionAsync(key);
if (sharedInfo != null)
{
if (sharedInfo.Created != cachedObj.Created)
{
// shared cached version is different, retrieve and save locally
SharedCacheObject sharedCacheObj = await DataProvider.GetAsync(key);
if (sharedCacheObj == null)
{
// this shouldn't happen, we just got the shared version
}
else
{
data = new GeneralFormatter().Deserialize <TYPE>(sharedCacheObj.Value);
sharedInfo = sharedCacheObj;
}
cachedObj = new StaticCacheObject {
Created = sharedInfo.Created,
Key = sharedInfo.Key,
Value = data,
};
localValid = true;
lock (_lockObject) { // used to protect StaticObjects - local only
StaticObjects.Remove(key);
StaticObjects.Add(key, cachedObj);
}
}
else
{
// shared version same as local version
}
return(new GetObjectInfo <TYPE> {
Success = true,
Data = data,
});
}
else
{
// there is no shared version
// no shared cache
if (!localValid)
{
return(new GetObjectInfo <TYPE> {
Success = false
});
}
else
{
return(new GetObjectInfo <TYPE> {
Success = true,
Data = data,
});
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Dt.Cells.Data.AutoFormatter" /> class.
/// </summary>
/// <param name="innerformatter">The inner formatter.</param>
public AutoFormatter(GeneralFormatter innerformatter)
{
this._innerformatter = innerformatter;
}
public static void SetFormatter(Worksheet worksheet, int row, int column, SheetArea area, GeneralFormatter gformatter)
{
if (area == SheetArea.Cells)
{
worksheet.Cells[row, column].Formatter = new AutoFormatter(gformatter);
}
if (area == (SheetArea.CornerHeader | SheetArea.RowHeader))
{
worksheet.RowHeader.Cells[row, column].Formatter = new AutoFormatter(gformatter);
}
if (area == SheetArea.ColumnHeader)
{
worksheet.ColumnHeader.Cells[row, column].Formatter = new AutoFormatter(gformatter);
}
}
/// <summary>
/// Sets the cell data.
/// </summary>
/// <param name="worksheet">The sheet</param>
/// <param name="area">The area</param>
/// <param name="rowIndex">Index of the row</param>
/// <param name="columnIndex">Index of the column</param>
/// <param name="value">The value</param>
/// <param name="opt">The opt</param>
static void SetCellData(Worksheet worksheet, SheetArea area, int rowIndex, int columnIndex, string value, ImportExportOptions opt)
{
object obj2 = value;
GeneralFormatter gformatter = null;
if (!opt.UnFormatted)
{
gformatter = new GeneralFormatter().GetPreferredDisplayFormatter(value, out obj2) as GeneralFormatter;
}
if (obj2 == null)
{
worksheet.SetValue(rowIndex, columnIndex, area, obj2);
}
else if (!object.Equals(value, ""))
{
if (!opt.Formula || !value.StartsWith("="))
{
StyleInfo info = worksheet.GetActualStyleInfo(rowIndex, columnIndex, area);
if (info != null)
{
if (!opt.UnFormatted)
{
if (info.Formatter == null)
{
SetFormatter(worksheet, rowIndex, columnIndex, area, gformatter);
}
else if (info.Formatter.FormatString == "@")
{
obj2 = value.ToString();
}
}
else if (info.Formatter != null)
{
if (area == SheetArea.Cells)
{
worksheet.Cells[rowIndex, columnIndex].ResetFormatter();
}
if (area == (SheetArea.CornerHeader | SheetArea.RowHeader))
{
worksheet.RowHeader.Cells[rowIndex, columnIndex].ResetFormatter();
}
if (area == SheetArea.ColumnHeader)
{
worksheet.ColumnHeader.Cells[rowIndex, columnIndex].ResetFormatter();
}
}
}
worksheet.SetValue(rowIndex, columnIndex, area, obj2);
}
else
{
try
{
worksheet.SetFormula(rowIndex, columnIndex, area, value.Substring(1));
}
catch
{
worksheet.SetText(rowIndex, columnIndex, area, value);
}
}
}
else
{
worksheet.SetValue(rowIndex, columnIndex, area, null);
}
}
bool ApplyEditorText(StyleInfo p_info)
{
var cell = _editingCell.BindingCell;
string formula = string.Empty;
using (((IUIActionExecuter)cell.Worksheet).BeginUIAction())
{
int index = cell.Row.Index;
int column = cell.Column.Index;
formula = cell.Formula;
if (formula == null)
{
object[,] objArray = cell.Worksheet.FindFormulas(index, column, 1, 1);
if (objArray.GetLength(0) > 0)
{
string str3 = objArray[0, 1].ToString();
int length = str3.Length;
if (((length > 2) && str3.StartsWith("{")) && str3.EndsWith("}"))
{
formula = str3.Substring(1, length - 2);
}
}
}
}
// 存在公式
if (!string.IsNullOrEmpty(formula))
{
Editor.Text = "=" + formula;
return(true);
}
if (cell.Value == null)
{
Editor.Text = string.Empty;
return(false);
}
string text;
// 存在格式化
var preferredEditingFormatter = new GeneralFormatter().GetPreferredEditingFormatter(cell.Value);
if ((preferredEditingFormatter != null) && (p_info.Formatter is AutoFormatter))
{
try
{
text = preferredEditingFormatter.Format(cell.Value);
}
catch
{
text = cell.Text;
}
}
else
{
text = cell.Text;
}
var formatter2 = p_info.Formatter;
if (formatter2 is GeneralFormatter formatter3)
{
switch (formatter3.GetFormatType(cell.Value))
{
case NumberFormatType.Number:
case NumberFormatType.Text:
formatter2 = new GeneralFormatter();
break;
}
}
if ((formatter2 != null) && !(formatter2 is AutoFormatter))
{
text = formatter2.Format(cell.Value);
}
if (text != null && text.StartsWith("=") && _ownPanel.Excel.CanUserEditFormula)
{
text = "'" + text;
}
Editor.Text = text;
return(false);
}
public async Task <GetObjectInfo <TYPE> > GetAsync <TYPE>(string key)
{
key = KeyPrefix + key;
key = GetKey(key);
// get cached version
TYPE data = default(TYPE);
StaticCacheObject cachedObj;
bool localValid;
lock (_lockObject) { // used to protect StaticObjects - local only
localValid = StaticObjects.TryGetValue(key, out cachedObj);
}
if (!localValid)
{
cachedObj = new StaticCacheObject {
Key = key,
Value = data,
Created = DateTime.MinValue,
};
}
else
{
data = (TYPE)cachedObj.Value;
}
// get shared cached version
IDatabase db = Redis.GetDatabase();
long? val;
if (YetaWFManager.IsSync())
{
val = (long?)db.StringGet(GetVersionKey(key));
}
else
{
val = (long?)await db.StringGetAsync(GetVersionKey(key));
}
if (val != null)
{
DateTime sharedCacheCreated = new DateTime((long)val);
if (sharedCacheCreated != cachedObj.Created)
{
// shared cached version is different, retrieve and save locally
byte[] sharedCacheData;
if (YetaWFManager.IsSync())
{
sharedCacheData = db.StringGet(GetDataKey(key));
}
else
{
sharedCacheData = await db.StringGetAsync(GetDataKey(key));
}
if (sharedCacheData == null)
{
data = default(TYPE);
}
else
{
data = new GeneralFormatter().Deserialize <TYPE>(sharedCacheData);
}
cachedObj = new StaticCacheObject {
Created = sharedCacheCreated,
Key = key,
Value = data,
};
localValid = true;
lock (_lockObject) { // used to protect StaticObjects - local only
StaticObjects.Remove(key);
StaticObjects.Add(key, cachedObj);
}
}
else
{
// shared version same as local version
}
return(new GetObjectInfo <TYPE> {
Success = true,
Data = data,
});
}
else
{
// no shared cache
if (!localValid)
{
return(new GetObjectInfo <TYPE> {
Success = false
});
}
else
{
return(new GetObjectInfo <TYPE> {
Success = true,
Data = data,
});
}
}
}
