Unit testing is a powerful way to ensure that your code works as intended. It’s a great way to combat the common “works on my machine” problem.
Read more here..
Source, Ingest, Prepare, Analyze and Consume
All about application services for example, Azure App Service. Angular application, Microsoft .NET Core and EF
Unit testing is a powerful way to ensure that your code works as intended. It’s a great way to combat the common “works on my machine” problem.
Read more here..
You can remove bullets by setting the list-style-type
to none
on the CSS for the parent element (typically a <ul>
), for example:
ul {
list-style-type: none;
}
You might also want to add padding: 0
and margin: 0
to that if you want to remove indentation as well.
See Listutorial for a great walkthrough of list formatting techniques.
For more info, continue reading on Stack Overflow
For more info on CSS box model, continue reading on W3 schools
What’s the difference between “{}” and “[]” while declaring a JavaScript array? Normally I declare like
var a = [];
What is the meaning of declaring the array as var a = {}
Some of the meaning and explanation between [] and {} are;
var a = {};
is an object-key-value pairs. var a = [];
is an array-values stored in sequential indexes. We are not creating array when we are using {}
, we are creating object
For more info, continue reading on Stack Overflow
Dapper provides different ways to work with transactions. The most common way is to use the BeginTransaction
method available on the IDbConnection
interface. That will return an instance of IDbTransaction
, which you can use with Execute
and Query
methods to add, remove and modify data in your database tables.
// Open the connection and start a transaction:
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
using (var tran = connection.BeginTransaction())
{
// Execute your queries here
tran.Commit(); //Or rollback
}
}
You can also use the TransactionScope
class, which provides a much simpler way to deal with transactions:
// Open the connection and start a transaction:
using (var scope = new TransactionScope())
{
// Execute your queries here
scope.Complete(); //Or it will automatically rollback
}
While using Dapper transaction, i have started getting this error;
"A TransactionScope must be disposed on the same thread that it was created."
Looking around, I figured this out;
In .NET Framework 4.5.1, there is a set of new constructors for TransactionScope that take a TransactionScopeAsyncFlowOption parameter.
According to the MSDN, it enables transaction flow across thread continuations. Here is an example;
using (var tx = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await SomeMethodInTheCallStackAsync()
.ConfigureAwait(false);
tx.Complete();
}
For complete detail, read this article.
Reference
How can i access a static getter from an instance of the class that implements that getter?
for example, i have this class:
class Component {
static get isComponent() { return true; }
constructor() {}
}
const c = new Component();
how can i call from “c” “isComponent” of “Component” class? I read around and all I found is something like that:
Object.getPrototypeOf(c).isComponent
but this is not working on my case because there is no “isComponent” method in Component prototype object. The above code works if I write the class like this:
Component.prototype.isComponent = () => { return true; }
but this is not the way i would like to write classes. What am I missing?
static
s become properties of the constructor function, which you can access on an instance via the constructor
property:
console.log(c.constructor.isComponent);
class Component {
static get isComponent() { return true; }
constructor() {}
}
const c = new Component();
console.log(c.constructor.isComponent); // true
Of course, that relies on constructor
not having been mucked with. 🙂 Before the class
syntax, you’d see people forgetting to set constructor
properly in inheritance hierarchies all the time. Thankfully, with class
syntax, it’s handled automatically so people forgetting is no longer an issue.
In theory, the instance may have an “own” constructor
property, shadowing the one on the prototype. So if that’s a concern, you could go to the prototype:
console.log(Object.getPrototypeOf(c).constructor.isComponent);
class Component {
static get isComponent() { return true; }
constructor() {}
}
const c = new Component();
console.log(Object.getPrototypeOf(c).constructor.isComponent); // true
Alternatively, if you know what constructor it is, you can go direct to the source:
console.log(Component.isComponent);
class Component {
static get isComponent() { return true; }
constructor() {}
}
// const c = new Component(); <== Don't need it
console.log(Component.isComponent); // true
..but only if you know in advance that Component
is the constructor you want.
For complete discussion, follow this link.