1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Data.SQLite;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tango.Core;
using Tango.Settings;
namespace Tango.BL
{
public partial class ObservablesContext
{
private List<ObservableModifiedEventArgs> _pending_notifications = new List<ObservableModifiedEventArgs>();
/// <summary>
/// Initializes a new instance of the <see cref="ObservablesContext" /> class.
/// </summary>
/// <param name="path">The server file path.</param>
/// <param name="isFile">if set to <c>true</c> will try to connect to an .mdf file.</param>
public ObservablesContext(String path, String dbName) : base(ComposeConnectionString(path, dbName))
{
Database.SetInitializer<ObservablesContext>(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="ObservablesContext"/> class.
/// </summary>
/// <param name="sqliteConnection">The SQLite connection.</param>
public ObservablesContext(SQLiteConnection sqliteConnection) : base(sqliteConnection, true)
{
Database.SetInitializer<ObservablesContext>(null);
}
/// <summary>
/// Composes the connection string.
///</summary>
/// <param name="source">The source.</param>
/// <param name="isFile">if set to <c>true</c> [is file].</param>
/// <returns></returns>
private static String ComposeConnectionString(String source, String dbName)
{
if (!File.Exists(source))
{
return String.Format("Data Source={0};Initial Catalog={1};Integrated Security=True;", source, dbName);
}
else
{
return String.Format("Data Source=(LocalDB)\\MSSQLLocalDB;AttachDbFileName={0};Initial Catalog={1};Integrated Security=True;MultipleActiveResultSets=True;App=EntityFramework", Path.GetFullPath(source), dbName);
}
}
/// <summary>
/// Creates a default remote database context by the address specified in <see cref="SettingsManager.Default.DataBase.SQLServerAddress" />.
/// </summary>
/// <returns></returns>
public static ObservablesContext CreateDefault()
{
var context = CreateDefault(SettingsManager.Default.GetOrCreate<CoreSettings>().DataBaseSource);
return context;
}
/// <summary>
/// Creates a default remote database context.
/// </summary>
/// <returns></returns>
public static ObservablesContext CreateDefault(String dataSource)
{
var source = dataSource;
if (File.Exists(source) && Path.GetExtension(source).ToLower() == ".db")
{
var connection = new SQLiteConnection()
{
ConnectionString = new SQLiteConnectionStringBuilder() { DataSource = Path.GetFullPath(source), ForeignKeys = true }.ConnectionString
};
return new ObservablesContext(connection);
}
else
{
return new ObservablesContext(source, "Tango");
}
}
/// <summary>
/// Creates a default remote database context.
/// </summary>
/// <returns></returns>
public static ObservablesContext CreateDefault(String address, String database)
{
return new ObservablesContext(address, database);
}
/// <summary>
/// Saves all changes made in this context to the underlying database.
/// </summary>
/// <returns>
/// The number of objects written to the underlying database.
/// </returns>
public override int SaveChanges()
{
var result = base.SaveChanges();
RaisePendingNotifications();
return result;
}
/// <summary>
/// Asynchronously saves all changes made in this context to the underlying database.
/// </summary>
/// <param name="cancellationToken">A <see cref="T:System.Threading.CancellationToken" /> to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous save operation.
/// The task result contains the number of objects written to the underlying database.
/// </returns>
/// <remarks>
/// Multiple active operations on the same context instance are not supported. Use 'await' to ensure
/// that any asynchronous operations have completed before calling another method on this context.
/// </remarks>
public override Task<int> SaveChangesAsync(CancellationToken cancellationToken)
{
var result = base.SaveChangesAsync(cancellationToken);
RaisePendingNotifications();
return result;
}
/// <summary>
/// Raises the pending notifications.
/// </summary>
private void RaisePendingNotifications()
{
Task.Factory.StartNew(() =>
{
foreach (var e in _pending_notifications.DistinctBy(x => x.NotifiedEntity))
{
try
{
e.NotifiedEntity.RaiseModified(e.Context, e.ModifiedEntity, e.NotifiedEntity);
}
catch { }
}
_pending_notifications.Clear();
});
}
/// <summary>
/// Extension point allowing the user to override the default behavior of validating only
/// added and modified entities.
/// </summary>
/// <param name="entityEntry">DbEntityEntry instance that is supposed to be validated.</param>
/// <returns>
/// true to proceed with validation; false otherwise.
/// </returns>
protected override bool ShouldValidateEntity(DbEntityEntry entityEntry)
{
if (entityEntry.State == EntityState.Modified && entityEntry.Entity is IObservableEntity)
{
IObservableEntity modified = entityEntry.Entity as IObservableEntity;
foreach (var toNotify in ObservableEntitiesContainer.RegisteredEntities.Where(x => x.Guid == modified.Guid))
{
_pending_notifications.Add(new ObservableModifiedEventArgs(this, modified, toNotify));
}
}
return base.ShouldValidateEntity(entityEntry);
}
}
}
|
