public BaseObject(int memoryAddress, ArraySegment<byte> originalBytes, IVersion version)
{
MemoryAddress = memoryAddress;
OriginalBytes = originalBytes;
DatabaseMode = DatabaseModeEnum.Cached;
Version = version;
}
public SourceDump(SourceDumperOptions options, UsageDefinition definition, IEnvironment environment,
IDebugger debugger, IConsole console, IVersion versionGetter,
IWriterFactory factory)
: base(options, definition, environment, debugger, console, versionGetter)
{
_factory = factory;
}
public static int CompareTo(
IVersion version1,
IVersion version2
)
{
int comparison = 0;
{
IList<int> version1Numbers = version1.Numbers;
IList<int> version2Numbers = version2.Numbers;
for(
int index = 0,
length = Math.Min(version1Numbers.Count, version2Numbers.Count);
index < length;
index++
)
{
comparison = version1Numbers[index] - version2Numbers[index];
if(comparison != 0)
break;
}
if(comparison == 0)
{comparison = version1Numbers.Count - version2Numbers.Count;}
}
return Math.Sign(comparison);
}
public void JoinArchive(string name, IArchive archive, IVersion version = null)
{
if (version != null)
throw new GitHubException("Method JoinArchive with version NotImplemented", new NotImplementedException());
var path = FullPath(name);
version = LastVersion(path).AddVersion(1);
archive.SaveTo(Path.Combine(path, version+".zip"));
}
public PocoAdapter(object poco, IOid oid) {
if (poco is INakedObject) {
throw new AdapterException("Adapter can't be used to adapt an adapter: " + poco);
}
this.poco = poco;
this.oid = oid;
ResolveState = new ResolveStateMachine(this);
version = new NullVersion();
}
protected ProgramDefinition(Options options, UsageDefinition definition, IEnvironment environment,
IDebugger debugger, IConsole console, IVersion versionGetter)
{
_options = options;
_definition = definition;
_environment = environment;
_debugger = debugger;
_console = console;
_versionGetter = versionGetter;
}
// Finds the process and loads it in memory
public bool findFMProcess ()
{
FMProcess fmProcess = new FMProcess ();
Process[] fmProcesses = Process.GetProcessesByName ("fm");
uint pid = fmProcesses.Length > 1 ? (uint)fmProcesses[0].Id : (uint)fmProcesses[0].Id;
if (fmProcesses.Length > 0) {
uint buffer;
uint bufferend;
uint heap;
uint endaddress;
if (ProcessMemoryAPI.GetBaseAddress (pid, out buffer, out bufferend, out heap, out endaddress)) {
fmProcess.Process = fmProcesses [0];
fmProcess.BaseAddress = (int)buffer;
fmProcess.HeapAddress = (int)heap;
fmProcess.EndPoint = (int)endaddress;
ProcessManager.fmProcess = fmProcess;
// Search for the current version
foreach (var versionType in Assembly.GetCallingAssembly().GetTypes().Where(t => typeof(IIVersion).IsAssignableFrom(t))) {
if (versionType.IsInterface)
continue;
var instance = (IIVersion)Activator.CreateInstance (versionType);
if (instance.SupportsProcess (fmProcess, null)) {
Version = instance;
break;
}
}
}
fmLoaded = (Version != null);
}
if (!fmLoaded) {
// Try to find info about the version
// Lookup the objects in the memory
for (int i = fmProcess.BaseAddress; i < fmProcess.EndPoint - 4; i += 4) {
try {
int continents = TryGetPointerObjects(i, 0x1c, fmProcess);
if (continents == 7)
{
Debug.WriteLine ("Found a candidate @ 0x{0:X}", i);
Debug.WriteLine ("Persons: {0}", TryGetPointerObjects(i, 0x3c, fmProcess));
}
}
catch {
}
}
}
return fmLoaded;
}
public static string ToString(
IVersion version
)
{
StringBuilder versionStringBuilder = new StringBuilder();
foreach(int number in version.Numbers)
{
if(versionStringBuilder.Length > 0)
{versionStringBuilder.Append('.');}
versionStringBuilder.Append(number);
}
return versionStringBuilder.ToString();
}
public IRevisionCollection CreateRevisionSet(IVersion version)
{
IEnumerable<ILogItem> logItems = this.GetLogItems(version);
ICollection<IRevision> revisions = new List<IRevision>();
foreach (ILogItem logItem in logItems)
{
IssueCollection issues = this.GetIssues(logItem.Tickets);
IRevisionOverride overrride = GetOverride(version, logItem.Revision);
revisions.Add(CreateRevision(logItem, issues, overrride));
}
var revisionCollection = new RevisionCollection(revisions);
return revisionCollection;
}
public INakedObjectAdapter CreateAdapter(object domainObject, IOid oid, IVersion version) {
if (domainObject == null) {
return null;
}
if (oid == null) {
ITypeSpec objectSpec = metamodel.GetSpecification(domainObject.GetType());
if (objectSpec.ContainsFacet(typeof (IComplexTypeFacet))) {
return GetAdapterFor(domainObject);
}
if (objectSpec.HasNoIdentity) {
return AdapterForNoIdentityObject(domainObject);
}
return AdapterForExistingObject(domainObject, objectSpec);
}
return AdapterForExistingObject(domainObject, oid);
}
public ReferenceManager(IUnityContainer container, ReferenceOptions options, UsageDefinition definition,
IEnvironment environment, IDebugger debugger, IConsole console, IVersion versionGetter)
: base(options, definition, environment, debugger, console, versionGetter)
{
_container = container;
}
/// <summary>
/// Finds the <see cref="IFeatureClass" /> with the specified <paramref name="tableName" /> in the
/// specified <paramref name="source" /> workspace.
/// </summary>
/// <param name="source">The workspace</param>
/// <param name="tableName">Name of the table.</param>
/// <returns>
/// Returns a <see cref="IFeatureClass" /> representing the feature class that has the name,
/// otherwise <c>null</c>.
/// </returns>
/// <exception cref="System.ArgumentNullException">tableName</exception>
public static IFeatureClass GetFeatureClass(this IVersion source, string tableName)
{
return(((IWorkspace)source).GetFeatureClass(tableName));
}
public Club(int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
this.ClubOffsets = new ClubOffsets(Version);
}
/// <summary>
/// Encapsulates the <paramref name="operation" /> by the necessary start and stop edit constructs using the specified
/// <paramref name="withUndoRedo" /> and
/// <paramref name="multiuserEditSessionMode" /> parameters.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="withUndoRedo">if set to <c>true</c> when the changes are reverted when the edits are aborted.</param>
/// <param name="multiuserEditSessionMode">
/// The edit session mode that can be used to indicate non-versioned or versioned
/// editing for workspaces that support multiuser editing.
/// </param>
/// <param name="operation">
/// The edit operation delegate that handles making the necessary edits. When the delegate returns
/// <c>true</c> the edits will be saved; otherwise they will not be saved.
/// </param>
/// <returns>
/// Returns a <see cref="bool" /> representing the state of the operation.
/// </returns>
/// <exception cref="System.ArgumentNullException">action</exception>
/// <exception cref="System.ArgumentException">
/// The workspace does not support the edit session
/// mode.;multiuserEditSessionMode
/// </exception>
public static bool PerformOperation(this IVersion source, bool withUndoRedo, esriMultiuserEditSessionMode multiuserEditSessionMode, Func <bool> operation)
{
return(((IWorkspace)source).PerformOperation(withUndoRedo, multiuserEditSessionMode, operation, error => false));
}
/// <summary>
/// Determines whether this instance is locked.
/// </summary>
/// <param name="source">The source.</param>
/// <returns>
/// <c>true</c> if the specified source is locked; otherwise, <c>false</c>.
/// </returns>
public static bool IsLocked(this IVersion source)
{
return(source.GetVersionLocks().Any());
}
public PlayerStats(int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
}
/// <summary>
/// Gets the differences between the <paramref name="source" /> and <paramref name="target" /> versions.
/// </summary>
/// <param name="source">The source (or child) version.</param>
/// <param name="target">The target (or parent) version.</param>
/// <param name="filter">The predicate to filter the results.</param>
/// <param name="differenceTypes">The type of differences that will be determined.</param>
/// <returns>
/// Returns a <see cref="Dictionary{String, DifferenceRow}" /> representing the differences for the
/// table (or key).
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// target
/// or
/// differenceTypes
/// </exception>
public static Dictionary <string, IEnumerable <DifferenceRow> > GetDifferences(this IVersion source, IVersion target, IQueryFilter filter, params esriDifferenceType[] differenceTypes)
{
if (source == null)
{
return(null);
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (differenceTypes == null)
{
throw new ArgumentNullException("differenceTypes");
}
return(source.GetDifferences(target, filter, (s, t) => t != null, differenceTypes));
}
public PackageIdentity(PackageId packageId, IVersion version, PackagePath path)
{
PackageId = packageId ?? throw new ArgumentNullException(nameof(packageId));
Version = version ?? throw new ArgumentNullException(nameof(version));
Path = path ?? throw new ArgumentNullException(nameof(path));
}
private static int IsReplacedBall(IVersion enc, PKM pk) => pk switch
{
public Team(int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
}
static string GetPackageFileName(string packageId, IVersion version)
{
return(packageId + "." + version + NuGetFileExtension);
}
public InstallResult Install(IVersion release, Action <IProgress> callback)
{
return(installer.Install(manifest, release.VersionFiles, DownloadRootDirectoryName, AppDomain.CurrentDomain.BaseDirectory, (progress) => { callback(progress); }));
}
public async Task <DownloadResult> Download(IVersion version, Action <DownloadProgress> callback)
{
return(await downloader.Download(manifest, version, DownloadRootDirectoryName, (progress) => { callback(progress); }));
}
public PlayerStats(int memoryAddress, ArraySegment <byte> originalBytes, IVersion version)
: base(memoryAddress, originalBytes, version)
{
}
public int CompareTo(
IVersion value
)
{
return VersionUtils.CompareTo(this, value);
}
public BaseObject(int memoryAddress, IVersion version)
{
MemoryAddress = memoryAddress;
Version = version;
DatabaseMode = DatabaseModeEnum.Realtime;
}
public Player (int memoryAddress, ArraySegment<byte> originalBytes, IVersion version)
: base(memoryAddress, originalBytes, version)
{
this.PlayerOffsets = new PlayerOffsets(version);
}
static string GetFullImageName(string packageId, IVersion version, Uri feedUri)
{
return(feedUri.Host.Equals(DockerHubRegistry)
? $"{packageId}:{version}"
: $"{feedUri.Authority}{feedUri.AbsolutePath.TrimEnd('/')}/{packageId}:{version}");
}
public PlayerStats(int memoryAddress, ArraySegment<byte> originalBytes, IVersion version)
: base(memoryAddress, originalBytes, version)
{
}
public RivalNation(int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
this.RivalNationOffsets = new RivalNationOffsets(version);
}
/// <summary>
/// Reconciles the current source version with the specified target version. The target version must be
/// an ancestor of the current version or an error will be returned.
/// </summary>
/// <param name="source">The source version that will be reconciled.</param>
/// <param name="target">The target version must be an ancestor of the current version or an error will be returned.</param>
/// <param name="acquireLock">
/// The default behavior of reconcile is to obtain a shared version lock on the target version. The lock ensures the
/// target version cannot be reconciled while the source version can be reconciled. The purpose of the version lock on
/// the target version is to ensure the version is available when the intention is to post. If the intention is not to
/// post to the target version following a reconcile, the acquireLock method can be set to false.
/// </param>
/// <param name="abortIfConflicts">
/// It is also possible to abort the reconcile when a conflict is detected. Setting the abortIfConflicts to true will
/// abort the reconcile process when conflicts are detected; for example, you could choose to abort when performing the
/// reconcile in a batch process when there is no human interaction to resolve the conflicts.
/// </param>
/// <param name="childWins">
/// If conflicts occur, the conflicts are initially resolved in favor of the target version. Setting this argument to
/// true replaces all conflicting features with the source version's representation of the object.
/// </param>
/// <param name="columnLevel">
/// The reconcile method also provides the ability to define what constitutes a conflict during the reconcile. The
/// columnLevel argument is a Boolean argument that, if set to true, will only promote the same modified object in both
/// versions as a conflict if the same attribute for the object has changed in both versions. For example, if a feature
/// was moved in the target version, the same feature's attribute was updated in the edit version, and column level
/// conflict filtering was set to true, the reconcile would not detect this feature as a conflict.
/// </param>
/// <returns>Returns a <see cref="bool"/> representing <c>true</c> when conflicts have been detected.</returns>
public static bool Reconcile(this IVersion source, IVersion target, bool acquireLock, bool abortIfConflicts, bool childWins, bool columnLevel)
{
IVersionEdit4 versionEdit = (IVersionEdit4)source;
return(source.PerformOperation(true, esriMultiuserEditSessionMode.esriMESMVersioned, () => versionEdit.Reconcile4(target.VersionName, acquireLock, abortIfConflicts, childWins, columnLevel)));
}
public RivalNation(int memoryAddress, ArraySegment <byte> originalBytes, IVersion version)
: base(memoryAddress, originalBytes, version)
{
this.RivalNationOffsets = new RivalNationOffsets(version);
}
/// <summary>
/// Encapsulates the <paramref name="operation" /> by the necessary start and stop edit constructs using the specified
/// <paramref name="withUndoRedo" />s
/// </summary>
/// <param name="source">The source.</param>
/// <param name="withUndoRedo">if set to <c>true</c> when the changes are reverted when the edits are aborted.</param>
/// <param name="operation">
/// The edit operation delegate that handles making the necessary edits. When the delegate returns
/// <c>true</c> the edits will be saved; otherwise they will not be saved.
/// </param>
/// <returns>
/// Returns a <see cref="bool" /> representing the state of the operation.
/// </returns>
/// <exception cref="System.ArgumentNullException">action</exception>
public static bool PerformOperation(this IVersion source, bool withUndoRedo, Func <bool> operation)
{
return(((IWorkspaceEdit)source).PerformOperation(withUndoRedo, operation, error => false));
}
/// <summary>
/// Initializes a new instance of the <see cref="DeltaRowCollection" /> class.
/// </summary>
/// <param name="modifiedClassInfo">The modified class information.</param>
/// <param name="source">The source (or child) version.</param>
/// <param name="target">The target (or parent) version.</param>
public DeltaRowCollection(IModifiedClassInfo modifiedClassInfo, IVersion source, IVersion target)
{
this.ModifiedClassInfo = modifiedClassInfo;
this.SourceVersion = source;
this.TargetVersion = target;
this.CommonAncestorVersion = target == null ? null : ((IVersion2)source).GetCommonAncestor(target);
}
/// <summary>
/// Finds the <see cref="ITable" /> with the specified <paramref name="tableName" /> in the
/// specified <paramref name="source" /> workspace.
/// </summary>
/// <param name="source">The workspace</param>
/// <param name="tableName">Name of the table.</param>
/// <returns>
/// Returns a <see cref="ITable" /> representing the table that has the name,
/// otherwise <c>null</c>.
/// </returns>
/// <exception cref="System.ArgumentNullException">tableName</exception>
public static ITable GetTable(this IVersion source, string tableName)
{
return(((IWorkspace)source).GetTable(tableName));
}
public ClubFinances (int memoryAddress, ArraySegment<byte> originalBytes, IVersion version)
: base(memoryAddress, originalBytes, version)
{
this.ClubFinancesOffsets = new ClubFinancesOffsets(version);
}
/// <summary>
/// Gets the differences between the <paramref name="source" /> and <paramref name="target" /> versions.
/// </summary>
/// <param name="source">The source (or child) version.</param>
/// <param name="target">The target (or parent) version.</param>
/// <param name="filter">The predicate to filter the results.</param>
/// <param name="predicate">
/// The predicate that defines a set of criteria and determines whether the specified differences
/// will be loaded.
/// </param>
/// <param name="differenceTypes">The type of differences that will be determined.</param>
/// <returns>
/// Returns a <see cref="Dictionary{String, DifferenceRow}" /> representing the differences for the
/// table (or key).
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// target
/// or
/// differenceTypes
/// </exception>
public static Dictionary <string, IEnumerable <DifferenceRow> > GetDifferences(this IVersion source, IVersion target, IQueryFilter filter, Func <string, ITable, bool> predicate, params esriDifferenceType[] differenceTypes)
{
if (source == null)
{
return(null);
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (differenceTypes == null)
{
throw new ArgumentNullException("differenceTypes");
}
var list = new Dictionary <string, IEnumerable <DifferenceRow> >();
IVersionDataChangesInit vdci = new VersionDataChangesClass();
IWorkspaceName wsNameSource = (IWorkspaceName)((IDataset)source).FullName;
IWorkspaceName wsNameTarget = (IWorkspaceName)((IDataset)target).FullName;
vdci.Init(wsNameSource, wsNameTarget);
IDataChanges dataChanges = (IDataChanges)vdci;
IEnumModifiedClassInfo enumMci = dataChanges.GetModifiedClassesInfo();
enumMci.Reset();
IModifiedClassInfo mci;
while ((mci = enumMci.Next()) != null)
{
// The table references are not disposed due to the enumerable return which would result in an RCW exception.
string tableName = mci.ChildClassName;
ITable sourceTable = ((IFeatureWorkspace)source).OpenTable(tableName);
if (predicate(tableName, sourceTable))
{
IVersionedTable versionedTable = sourceTable as IVersionedTable;
ITable table = ((IFeatureWorkspace)target).OpenTable(tableName);
if (versionedTable != null && table != null)
{
var rows = versionedTable.GetDifferences(table, filter, differenceTypes);
list.Add(tableName, rows);
}
}
}
return(list);
}
public Continent(int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
}
public void ReconcileandPost(IVersion editVersion, IVersion targetVersion)
{
IMultiuserWorkspaceEdit muWorkspaceEdit = (IMultiuserWorkspaceEdit)editVersion;
IWorkspaceEdit workspaceEdit = (IWorkspaceEdit2)editVersion;
IVersionEdit4 versionEdit = (IVersionEdit4)workspaceEdit;
if (muWorkspaceEdit.SupportsMultiuserEditSessionMode(esriMultiuserEditSessionMode.esriMESMVersioned))
{
muWorkspaceEdit.StartMultiuserEditing(esriMultiuserEditSessionMode.esriMESMVersioned);
//Reconcile with the target version.
bool conflicts = versionEdit.Reconcile4(targetVersion.VersionName, true, false, false, false);
if (conflicts) MessageBox.Show(" Conflicts Detected ");
else MessageBox.Show(" No Conflicts Detected ");
workspaceEdit.StartEditOperation();
//Post to the target version.
if (versionEdit.CanPost()) versionEdit.Post(targetVersion.VersionName);
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
}
}
public NationOffsets(IVersion version)
{
this.Version = version;
}
public NationTaxRulesOffsets (IVersion version)
{
this.Version = version;
}
public RivalNation (int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
this.RivalNationOffsets = new RivalNationOffsets(version);
}
public Player (int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
this.PlayerOffsets = new PlayerOffsets(version);
}
public void CheckLock(IVersion otherVersion) {
throw new System.NotImplementedException();
}
public static bool CanBeReceivedBy(this IVersion ver, GameVersion game) => ver.Version.Contains(game);
/// <summary>
/// Initializes a new instance of the <see cref="DeltaRowCollection" /> class.
/// </summary>
/// <param name="modifiedClassInfo">The modified class information.</param>
/// <param name="source">The source.</param>
public DeltaRowCollection(IModifiedClassInfo modifiedClassInfo, IVersion source)
: this(modifiedClassInfo, source, null)
{
}
public ClubFinances (int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
this.ClubFinancesOffsets = new ClubFinancesOffsets(version);
}
public VersionController(IVersion versionService, IValidate validateService)
{
_versionService = versionService;
_validateService = validateService;
}
public ContractClause(int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
}
public int CompareTo(IVersion other)
{
return(Version.Compare(this, other));
}
public Continent(int memoryAddress, ArraySegment<byte> originalBytes, IVersion version)
: base(memoryAddress, originalBytes, version)
{
}
public Injury(int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
}
public Person(int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
this.PersonOffsets = new PersonOffsets(version);
}
public Injury(int memoryAddress, ArraySegment <byte> originalBytes, IVersion version)
: base(memoryAddress, originalBytes, version)
{
}
public RivalNation(int memoryAddress, ArraySegment<byte>originalBytes, IVersion version)
: base(memoryAddress, originalBytes, version)
{
this.RivalNationOffsets = new RivalNationOffsets(version);
}
public Club(int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
this.ClubOffsets = new ClubOffsets(Version);
}
public PlayerStats(int memoryAddress, IVersion version)
: base(memoryAddress, version)
{
}
public Club(int memoryAddress, ArraySegment <byte> originalBytes, IVersion version)
: base(memoryAddress, originalBytes, version)
{
this.ClubOffsets = new ClubOffsets(Version);
}
public TeamOffsets(IVersion version)
{
this.Version = version;
}
/// <summary>
/// Gets the differences between the <paramref name="source" /> and <paramref name="target" /> versions that need to be
/// checked-in or exported.
/// </summary>
/// <param name="source">The source (or child) version.</param>
/// <param name="target">The target (or parent) version.</param>
/// <param name="predicate">
/// The predicate that defines a set of criteria and determines whether the specified differences
/// will be loaded.
/// </param>
/// <param name="dataChangeTypes">The data change types.</param>
/// <returns>
/// Returns a <see cref="Dictionary{String, DeltaRow}" /> representing the differences for the table (or
/// key).
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// target
/// or
/// predicate
/// or
/// dataChangeTypes
/// </exception>
public static Dictionary <string, DeltaRowCollection> GetDataChanges(this IVersion source, IVersion target, Func <IModifiedClassInfo, bool> predicate, params esriDataChangeType[] dataChangeTypes)
{
if (source == null)
{
return(null);
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (predicate == null)
{
throw new ArgumentNullException("predicate");
}
if (dataChangeTypes == null)
{
throw new ArgumentNullException("dataChangeTypes");
}
var list = new Dictionary <string, DeltaRowCollection>(StringComparer.Create(CultureInfo.InvariantCulture, true));
IVersionDataChangesInit vdci = new VersionDataChangesClass();
IWorkspaceName wsNameSource = (IWorkspaceName)((IDataset)source).FullName;
IWorkspaceName wsNameTarget = (IWorkspaceName)((IDataset)target).FullName;
vdci.Init(wsNameSource, wsNameTarget);
IDataChanges dataChanges = (IDataChanges)vdci;
IDataChangesInfo dci = (IDataChangesInfo)vdci;
var tasks = new List <Action>();
IEnumModifiedClassInfo enumMci = dataChanges.GetModifiedClassesInfo();
foreach (var mci in enumMci.AsEnumerable())
{
// Validate that the table needs to be loaded.
if (predicate(mci))
{
string tableName = mci.ChildClassName;
tasks.Add(() =>
{
var rows = new DeltaRowCollection(mci, source, target);
var actions = new List <Action>();
// Determines if the table represents a feature class.
bool isFeatureClass = mci.DatasetType == esriDatasetType.esriDTFeatureClass;
// Iterate through all of the data change types.
foreach (var dataChangeType in dataChangeTypes)
{
actions.Add(() =>
{
// IRow objects returned from a difference cursor are meant to be a read only. Thus, only the OIDs are being loaded and
// the rows are hydrated from the struct.
IFIDSet set = dci.ChangedIDs[tableName, dataChangeType];
set.Reset();
int oid;
set.Next(out oid);
while (oid != -1)
{
var row = new DeltaRow(dataChangeType, oid, tableName, isFeatureClass);
rows.Add(row);
set.Next(out oid);
}
});
}
if (actions.Any())
{
Task.WaitAll(actions);
}
list.Add(tableName, rows);
});
}
}
if (tasks.Any())
{
Task.WaitAll(tasks);
}
return(list);
}
